package com.beiyou;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidPooledConnection;
import com.beiyou.servlet.Student;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.io.InputStream;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * @author LittleDesire
 * @description
 * @date 2022-03-07 周一 15:04
 * @since 17
 */
public class druid练习 {
    @Test
    @DisplayName("commons-dbutils演示")
    public void t5() throws IOException, SQLException {
        DruidDataSource dds = new DruidDataSource();
        InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("druid.properties");
        var prop = new Properties();
        prop.load(is);
        dds.setConnectProperties(prop);


        // 使用commons-dbutils工具
        QueryRunner run = new QueryRunner(dds);

/*
ArraHandler         将结果集中的第-条记录封装到一个object[]数组中,数组中的每一个元素 就是这条记录中的每-个字段的值。
ArraListHandler2    将结果集中的每一条记录都封装到一个object[数组中，将这些数组在封装到List集合中。。
BeanHandler         将结果集中第一条记录封装到一个指定的javaBean中。。
BeanListHandler     将结果集 中每一条记录封装到指定的javaBean中,将这些javaBean在封装到List集合中。
ColumnListHandler   将结果集中指定的列的字段值，封装到一个List 集合中。
KeyedHandler        将结果集中每一条记录封装到Map<string,Object>,在将这个map集合做为另-个Map的value,
                    另一个Map集合的key是指定的字段的值。。
MapHandler          将结果集中第-条记录封装到了Map<string,0bject> 集合中, key就是字段名称，value就是字段值。
MapListHandler      将结果集中每-条记录封装到了Map<String,Object>集合中, key就是字段名称,value就是字段值，
                    在将这些Map封装到List 集合中。。
ScalarHandler       它是用于单个数据。例如select count(*) from表操作。
*/
        // ColumnListHandler   将结果集中指定的列的字段值，封装到一个List 集合中。
        List<Object> show_tables = run.query("show tables", new ColumnListHandler<>());
        //show_tables.forEach(System.out::println);
        List<Object> name = run.query("select name from db.t_student", new ColumnListHandler<>());
        //name.forEach(System.out::println);
        // 分页
        List<String> query1 = run.query("select name from db.t_student limit 5", new ColumnListHandler<>());
        System.out.println(query1);


        // ScalarHandler       它是用于单个数据。例如select count(*) from表操作。(单个值)
        String query = run.query("select version()", new ScalarHandler<>());
        System.out.println(query);
        String count = run.query("select database()", new ScalarHandler<>());
        System.out.println(count);
        Long cc = run.query("select count(*) from db.t_student", new ScalarHandler<>());
        System.out.println(cc);//27 求某表记录总数

        // MapListHandler      将结果集中每-条记录封装到了Map<String,Object>集合中, key就是字段名称,value就是字段值，
        //                    在将这些Map封装到List 集合中。。
        List<Map<String, Object>> list = run.query("select * from db.t_student", new MapListHandler());
        System.out.println(list);
        System.out.println(list.get(1));  // 获取第一行数据
        System.out.println(list.get(1).get("id")); // 获取第一行数据的 id 字段
        System.out.println(list.size());    // 获取集合的大小

        // 封装成一个实体类对象
        List<Student> st = run.query("select id,name,ufile from db.t_student", new BeanListHandler<>(Student.class));
        System.out.println(st);
        // 拿到id=99673030187286528 的Student对象
        List<Student> students = run.query("select * from db.t_student where id = 99673030187286528", new BeanListHandler<>(Student.class));
        System.out.println(students);


    }


    @Test
    @DisplayName("使用连接池连接的第四种方式")
    public void t4() throws SQLException, IOException {
        DruidDataSource dds = new DruidDataSource();
        InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("druid.properties");
        Properties prop = new Properties();
        prop.load(is);
        dds.setConnectProperties(prop);
        System.out.println(dds.getConnection());
         /*
        dds.setUrl(db.getProperty("db.url"));
        dds.setUsername(db.getProperty("db.username"));
        dds.setDriverClassName(db.getProperty("db.driver"));
        dds.setPassword(db.getProperty("db.password"));*/
        DruidPooledConnection conn = dds.getConnection();
        PreparedStatement ps = conn.prepareStatement("show databases");
        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            System.out.println(rs.getString(1));
        }


    }

    @Test
    @DisplayName("使用连接池连接的第三种方式")
    public void t3() throws SQLException {
        DruidDataSource dds = new DruidDataSource();
        Properties prop = new Properties();
        prop.setProperty("druid.url", "jdbc:mysql://localhost:3306");
        prop.setProperty("druid.username", "root");
        prop.setProperty("druid.password", "123");
        dds.setConnectProperties(prop);
        System.out.println(dds.getConnection());
    }

    @Test
    @DisplayName("使用连接池连接的第一种方式")
    public void t2() throws SQLException {
        DruidDataSource dds = new DruidDataSource();
        dds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dds.setUrl("jdbc:mysql://localhost:3306/db?user=root&password=123");
        System.out.println(dds.getConnection());
    }

    @Test
    @DisplayName("使用连接池连接的第二种方式")
    public void t1() throws SQLException {
        DruidDataSource dds = new DruidDataSource();
        // 设置初始化连接数量
        dds.setInitialSize(10);
        // 最大连接池数量
        dds.setMaxActive(50);

        dds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dds.setUrl("jdbc:mysql://localhost:3306/db");
        dds.setUsername("root");
        dds.setPassword("123");
        DruidPooledConnection conn = dds.getConnection();
        System.out.println(conn);
        System.out.println(conn.getCatalog());
        System.out.println(conn.getMetaData().getDatabaseProductVersion());


        DruidPooledConnection conn2 = dds.getConnection();
        // false 说明连接池的每个链接是独立的
        System.out.println((conn == conn2));

        PreparedStatement ps = conn2.prepareStatement("select *from t_student");
        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            System.out.println(rs.getObject(2));
        }
        rs.close();
        ps.close();
        conn.close();

    }
}
